﻿#include <iostream>
#include<vector>
#include<set>
#include <cctype> 
#include<string>
#include<unordered_map>
#include<unordered_set>
#include <algorithm> 
using namespace std;
////void solve()
////{
////    int n, m;
////    cin >> m >> n;
////    vector<vector<int>> arr(m, vector<int>(n));
////    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
////    for (int i = 0; i < m; i++)//5
////        for (int j = 0; j < n; j++)//6
////        {
////            cin >> arr[i][j];
////        }
////
////    for (int i = 1; i <= m; i++)
////        for (int j = 1; j <= n; j++)
////        {
////            dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + arr[i - 1][j - 1];
////        }
////    int ret = 0;
////    for (int i = 1; i <= m; i++)
////        for (int j = 1; j <= n; i++)
////        {
////            int x1 = i, y1 = j;
////            for (int k = 0; k < min(m, n) - 1; k++)
////            {
////                int x2 = x1 + k, y2 = j + k;
////                if (x2 < m && y2 < n)
////                    ret = max(dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1], ret);
////            }
////        }
////    cout << ret;
////}
////int main()
////{
////    solve();
////    return 0;
////}
//// for toupper
//bool isPalindrome(string s) {
//    string screen;
//    for (char& ch : s) {
//        if (isalnum(ch)) {
//            screen  += tolower(ch);
//        }
//    }
//    int flag = 0;
//    int left = 0, right = screen.size() - 1;
//    while (left < right)
//    {
//        if (screen[left] == screen[right]) left++, right++;
//        else return false;
//    }
//    return true;
//}
//int main() {
//    //std::string str = "example string to uppercase";
//
//    //// 使用 for 范围循环来遍历字符串中的每个字符
//    //for (char& c : str) {
//    //    
//    //    c = toupper(c); // 将字符转换为大写
//    //}
//
//    //std::cout << str << std::endl;
//    isPalindrome("A man, a plan, a canal: Panama");
//    return 0;
//}
//struct TreeNode {
//    int val;
//    TreeNode* left;
//    TreeNode* right;
//    TreeNode() : val(0), left(nullptr), right(nullptr) {}
//    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
//    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
//};
//TreeNode* pruneTree(TreeNode* root) 
//{
//    if (root == nullptr) return nullptr;
//
//    TreeNode* left = pruneTree(root->left);
//    TreeNode* right = pruneTree(root->right);
//
//    if (left == nullptr && right == nullptr || root->val == 0)return nullptr;
//    else return root;
//}
//int main()
//{
//    TreeNode* root = new TreeNode(1);
//    root->left = new TreeNode(0);
//    root->right = new TreeNode(1);
//    /*root->left->left = new TreeNode(0);
//    root->left->right = new TreeNode(0);
//    root->right->left = new TreeNode(0);
//    root->right->right = new TreeNode(1);*/
//
//    pruneTree(root);
//    return 0;
//}

//bool containsNearbyDuplicate(vector<int>& nums, int k) 
//{
//    unordered_map<int, int>hash;
//    for (int i = 0; i < nums.size(); i++)
//    {
//        if (hash.find(hash[nums[i]]) != hash.end() && abs(hash[nums[i]] - i) <= k) return true;
//        hash[nums[i]] = i;
//    }
//    return false;
//}
//1-0
//string longestPalindrome(string s) {
//    int n = s.size();
//    int begin = 0, len = 0;
//    for (int i = 0; i < n; i++)
//    {
//        //奇数
//        int left = i, right = i;
//        while (left >= 0 && right < n && s[left] == s[right])
//        {
//            left--;
//            right++;
//        }
//        if (right - left - 1 > len)
//        {
//            begin = left;
//            len = right - left - 1;
//        }
//        //偶数
//        left = i, right = i;
//        while (left >= 0 && right < n && s[left] == s[right])
//        {
//            left--;
//            right++;
//        }
//        if (right - left - 1 > len)
//        {
//            begin = left;
//            len = right - left - 1;
//        }
//    }
//    return s.substr(begin, len);
//}
//string add(string s1, string s2)
//{
//    int left = 0, right = 0, t = 0;
//    string ret;
//    while (left < s1.size() || right < s2.size() || t != 0)
//    {
//        if (left < s1.size())  t += s1[left++] - '0';
//        if (right < s2.size()) t += s2[right++] - '0';
//        ret += t % 10 + '0';
//        t /= 10;
//    }
//    return ret;
//}
//string multiply(string num1, string num2)
//{
//    //1.逆序
//    if (num2.size() > num1.size())
//        swap(num1, num2);
//    int m = num1.size(), n = num2.size();
//    reverse(num1.begin(), num1.end());
//    reverse(num2.begin(), num2.end());
//    string ret;
//    //固定num2
//    for (int i = 0; i < n; i++)
//    {
//        string tmp;
//        for (int k = 0; k < i; k++) tmp += '0';
//
//        int t = 0, cur = 0;
//        while (cur < m || t != 0)
//        {
//            if (cur < m)t += (num1[cur++] - '0') * (num2[i] - '0');
//            tmp += t % 10 + '0';
//            t /= 10;
//        }
//        ret = add(ret, tmp);
//    }
//    reverse(ret.begin(), ret.end());
//
//    return ret;
//}
//string removeDuplicates(string s) 
//{
//    string stack;
//    for (auto ch : s)
//    {
//        if (stack.size() && ch == stack.back()) stack.pop_back();
//        else stack += ch;
//    }
//    return stack;
//}
//int maxProfit(vector<int>& prices, int fee)
//{
//    int n = prices.size();
//    vector<int> f(n);
//    vector<int> g(n);
//
//    f[0] = -prices[0];
//    for (int i = 1; i < n; i++)
//    {
//        f[i] = max(f[i - 1], g[i - 1] - prices[i]);
//        g[i] = max(g[i - 1], f[i - 1] + prices[i] - fee);    
//    }
//    cout << g[n - 1];
//    return g[n - 1];
//}
//#include<stack>
//string decodeString(string s) {
//    stack<int> nums;
//    stack<string> st;
//    st.push("");
//    int i = 0, n = s.size();
//    while (i < n)
//    {
//        if (s[i] >= '0' && s[i] <= '9')
//        {
//            int t = 0;
//            while (s[i] >= '0' && s[i] <= '9') t = t * 10 + (s[i++] - '0');
//            nums.push(t);
//        }
//        else if (s[i] == '[')
//        {
//            i++;
//            string str = "";
//            while (s[i] >= 'a' && s[i] <= 'z')
//            {
//                str += s[i++];
//            }
//            st.push(str);
//        }
//        else if (s[i] == ']')
//        {
//            string str = st.top();
//            st.pop();
//            int k = nums.top();
//            nums.pop();
//            while (k--) st.top() += str;
//            i++;
//        }
//        else
//        {
//            string str = "";
//            while (i < n && s[i] >= 'a' && s[i] <= 'z')
//            {
//                str += s[i++];
//            }
//            st.top() += str;
//        }
//    }
//    return st.top();
//}
//bool check(vector<int>& nums, int m, int mid)
//{
//    int count = 1, last = nums[0];
//
//    for (int i = 1; i < nums.size(); i++)
//    {
//        if (nums[i] - last >= mid)
//        {
//            count++;
//            last = nums[i];
//            if (count == m) return true;
//        }
//    }
//    return false;
//}
//int maxDistance(vector<int>& nums, int m) {
//    sort(nums.begin(), nums.end());
//    int left = 1, right = nums.back() - nums[0];
//    int ret = 0;
//    while (left <= right)
//    {
//        int mid = left + (right - left) >> 1;
//        if (check(nums, m, mid))
//        {
//            ret = mid;
//            left = mid + 1;
//        }
//        else right = mid - 1;
//    }
//    return ret;
//}
//void RangeFreqQuery(vector<int>& arr)
//{
//    unordered_map<int, vector<int>> nums;
//    for (int i = 0; i < arr.size(); i++)
//    {
//        nums[arr[i]].push_back(i);
//    }
//
//    int left = 0, right = 11, value = 33;
//    auto l = lower_bound(nums[value].begin(), nums[value].end(), left);
//    auto r = upper_bound(nums[value].begin(), nums[value].end(), right);
//    cout << l - r;
//}
//int main()
//{
//    vector<int> nums({ 12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56 });
//    RangeFreqQuery(nums);
//    return 0;
//}

//#include <iostream>
//#include <vector>
//using namespace std;
//
//int main() {
//    int t;
//    cin >> t;
//
//    while (t--)
//    {
//        int n;
//        cin >> n;
//        vector<int> b(n - 2);
//
//        for (int i = 0; i < n - 2; ++i) cin >> b[i];
//        bool p = true;
//
//        for (int i = 0; i < n - 3; ++i)
//        {
//            if (i!= 0 &&  b[i-1] == 1 && b[i] == 0 && b[i + 1] == 1)
//            {
//                p = false;
//                break;
//            }
//        }
//        if (p)  cout << "YES" << endl;
//        else  cout << "NO" << endl;
//    }
//
//    return 0;
//}
//
//
//#include<iostream>
//#include<string>
//#include<vector>
//#include <algorithm>
//using namespace std;
//
//int main()
//{
//	vector<string> dp(4);
//	for (int i = 0; i <= 3; i++)
//		cin >> dp[i];
//	sort(dp.begin(), dp.end());
//	string result = "";
//
//	for (string& s : dp)
//	{
//		result += s;
//	}
//
//	cout << result << endl;
//	return 0;
//}
#include<iostream>
#include<queue>
using namespace std;

//int main()
//{
//	int a;
//	int count = 0;
//	cin >> a;
//	vector<int> arr(a);
//	for (int i = 0; i < a; i++)
//		cin >> arr[i];
//	priority_queue<int> q;
//	for (int i = 0; i < arr.size(); i++)
//	{
//		if (q.empty() || q.top() < arr[i])
//		{
//			q.push(arr[i]);
//			count++;
//		}
//	}
//	cout << count;
//	return 0;
//}
//int main()
//{
//	int n = 0, m = 0, count = 0, cur = 0;
//	cin >> n;
//	vector<int> e(n);
//	for (int i = 0; i < n; i++) cin >> e[i];
//	cin >> m;
//	vector<int> v(m);
//	for (int i = 0; i < m; i++) cin >> v[i];
//	for (auto& x : v)
//	{
//		if (cur < e.size() && x >= e[cur++]) count++;
//	}
//	cout << count;
//	return 0;
//}
//int main()
//{
//    int n = 0, ret = 0;
//    cin >> n;
//    string arr1, arr2;
//    cin >> arr1 >> arr2;
//    int maxn = count(arr1.begin(), arr1.end(), '1');
//    int maxm = count(arr2.begin(), arr2.end(), '1');
//
//    return maxm + maxn > n ? abs(maxn - maxm) : max(maxn, maxm);
//}


//int minMutation(string startGene, string endGene, vector<string>& bank)
//{
//    unordered_set<string> vis;
//    unordered_set<string> hash(bank.begin(), bank.end());
//
//    string change = "ACGT";
//
//    if (startGene == endGene) return 0;
//    if (!hash.count(endGene)) return -1;
//
//    queue<string> q;
//    q.push(startGene);
//    vis.insert(startGene);
//
//    int ret = 0;
//    while (q.size())
//    {
//        ret++;
//        int sz = q.size();
//        while (sz--)
//        {
//            string t = q.front();
//            q.pop();
//            for (int i = 0; i < 8; i++)
//            {
//                string tmp = t;
//                for (int j = 0; j < 4; j++)
//                {
//                    tmp[i] = change[j];
//                    if (hash.count(tmp) && !vis.count(tmp))
//                    {
//                        if (tmp == endGene) return ret;
//                        q.push(tmp);
//                        vis.insert(tmp);
//                    }
//                }
//            }
//        }
//    }
//    return -1;
//}

//int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
//    unordered_set<string> vis;
//    unordered_set<string> hash(wordList.begin(), wordList.end());
//    int size = beginWord.size();
//
//    if (beginWord == endWord || !hash.count(endWord)) return 0;
//
//    queue<string> q;
//    q.push(beginWord);
//    vis.insert(beginWord);
//
//    int ret = 0;
//    while (q.size())
//    {
//        ret++;
//        int n = q.size();
//        while (n--)
//        {
//            string t = q.front();
//            q.pop();
//            for (int i = 0; i < size; i++)
//            {
//                string tmp = t;
//                for (int j = 'a'; j <= 'z'; j++)
//                {
//                    tmp[i] = j;
//                    if (hash.count(tmp) && !vis.count(tmp))
//                    {
//                        if (tmp == endWord) return ret;
//                        q.push(tmp);
//                        vis.insert(tmp);
//                    }
//                }
//            }
//        }
//    }
//    return 0;
//}
//int main()
//{
//    string start = "hit",end = "cog";
//    vector<string> bank({"hot","dot","dog","lot","log","cog" });
//    cout<<ladderLength(start, end, bank);
//
//    return 0;
//}

//int dx[4] = { 0,0,1,-1 };
//int dy[4] = { 1,-1,0,0 };
//vector<vector<int>> highestPeak(vector<vector<int>>& isWater)
//{
//    int m = isWater.size(), n = isWater[0].size();
//    vector<vector<int>> vis(m, vector<int>(n, -1));
//    queue<pair<int, int>>q;
//    for (int i = 0; i < m; i++)
//        for (int j = 0; j < n; j++)
//        {
//            if (isWater[i][j] == 1)
//            {
//                q.push({ i,j });
//                vis[i][j] = 0;
//            }
//        }
//
//    while (q.size())
//    {
//        auto a = q.front().first;
//        auto b = q.front().second;
//        q.pop();
//        for (int i = 0; i < 4; i++)
//        {
//            int x = a + dx[i], y = b + dy[i];
//            if (x >= 0 && y >= 0 && x < m && y < n && vis[x][y] == -1 && isWater[x][y] == 0)
//            {
//                vis[x][y] = vis[a][y] + 1;
//                q.push({ x,y });
//            }
//        }
//    }
//    return vis;
//}
//    int main()
//    {
//        vector<vector<int>> arr{ { 0,1 }, { 0, 0 }};
//        highestPeak(arr);
//        return 0;
//    }

//int dx[2] = { -1,1 };
//void solve()
//{
//    int n;
//    cin >> n;
//    vector<int> arr(n + 1);
//    vector<int> dirt(n);
//    vector<bool> vis(n);
//    queue<int> q;
//    for (int i = 0; i < n; i++)
//    {
//        cin >> arr[i];
//        if (arr[i] == 1)
//        {
//            q.push(i);
//            dirt[i] = 0;
//        }
//    }
//    while (q.size())
//    {
//        auto a = q.front();
//        q.pop();
//        for (int i = 0; i < 2; i++)
//        {
//            int x = a + dx[i];
//            if (x >= 0 && x < n && dirt[x] == 0 && !vis[x])
//            {
//                dirt[x] = dirt[a] + 1;
//                q.push(x);
//            }
//        }
//    }
//    for (auto x : dirt)
//    {
//        if (x == 0) break;
//        cout << x << " ";
//    }
//}
//struct ListNode {
//    int val;
//    struct ListNode* next;
//    ListNode(int x) : val(x), next(nullptr) {}
//};
//ListNode* reserve(ListNode* head)
//{
//    ListNode* p = nullptr, * n = head, * nn = n->next;
//    while (nn != nullptr)
//    {
//        p = n;
//        n = nn;
//        nn = nn->next;
//        n->next = p;
//    }
//    return n;
//}
//ListNode* addInList(ListNode* head1, ListNode* head2)
//{
//    ListNode* n1 = reserve(head1);
//    ListNode* n2 = reserve(head2);
//
//    int t = 0;
//    ListNode* newhead = new ListNode(0);
//    ListNode* prev = newhead;
//    while (n1  || n2 || t != 0)
//    {
//        if (n1)
//        {
//            t += n1->val;
//            n1 = n1->next;
//        }
//        if (n2 )
//        {
//            t += n2->val;
//            n2 = n2->next;
//        }
//        prev->next = new ListNode(t % 10);
//        prev = prev->next;
//        t /= 10;
//    }
//    return reserve(newhead->next);
//}
//int main()
//{
//    ListNode* head1 = new ListNode(9);
//    head1->next = new ListNode(3);
//    head1->next->next = new ListNode(7);
//
//    ListNode* head2 = new ListNode(6);
//    head2->next = new ListNode(3);
//
//    addInList(head1, head2);
//    return 0;
//}

//int main()
//{
//    int n;
//    cin >> n;
//    vector<int> nums(n);
//    for (int i = 0; i < n; i++) cin >> nums[i];
//
//    vector<int>dp(n, 0);
//    for (int i = 2; i <= n; i++)
//    {
//        dp[i] = min(dp[i - 1] + nums[i - 1], dp[i - 2] + nums[i - 2]);
//    }
//    cout << dp[n] << endl;
//    return 0;
//}
//class Solution
//{
//    int dx[4] = { 0,0,-1,1 };
//    int dy[4] = { -1,1,0,0 };
//    bool vis[201][201] = { false };
//    int n, m;
//public:
//    void dfs(vector<vector<char> >& grid, int ex, int ey)
//    {
//        queue<pair<int, int>>q;
//        q.push({ ex,ey });
//        vis[ex][ey] = true;
//        while (q.size())
//        {
//            auto [a, b] = q.front();
//            q.pop();
//            for (int i = 0; i < 4; i++)
//            {
//                int x = a + dx[i], y = b + dy[i];
//                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1' && !vis[x][y])
//                {
//                    q.push({ x,y });
//                    vis[x][y] = true;
//                }
//            }
//        }
//       
//    }
//    int solve(vector<vector<char> >& grid)
//    {
//        n = grid[0].size(), m = grid.size();
//        int ret = 0;
//        for (int i = 0; i < m; i++)
//        {
//            for (int j = 0; j < n; j++)
//            {
//                if (grid[i][j] == '1' && !vis[i][j])
//                {
//                    ret++;
//                    dfs(grid, i, j);
//                }
//            }
//        }
//        return ret;
//    }

//class Solution {
//public:
//    int MLS(vector<int>& arr)
//    {
//        sort(arr.begin(), arr.end());
//        int ret = 1;
//        for (int cur = 0; cur <= arr.size(); cur++)
//        {
//            if (cur != 0 && arr[cur] == arr[cur - 1] + 1)
//            {
//                int j = cur - 1;
//                while (arr[cur] == arr[cur - 1] + 1 && cur <= arr.size())
//                {
//                    cur++;
//                }
//                if (ret < cur - j)
//                {
//                    ret = max(ret, cur - j);
//                }
//            }
//        }
//        return ret;
//    }
//};
//
//
//int main()
//{
//	char ch ;
//	cout << (char)toupper('a') << endl; // 'A'
//	cout << (char)tolower('B') << endl;  // 'b'
//
//	int num = 123;
//	string str = to_string(num);  // "123"
//
//	string str = "123";
//	int num = std::stoi(str);  // 123
//
//	return 0;
//}
//bool check(int n) {
//    string s = to_string(n);
//    for (int i = 0; i < s.size(); i++) {
//        int digit = s[i] - '0';
//        int pos = s.size() - i; // 从右往左数第几位（1-based）
//        if (pos % 2 == 1) { // 奇数位（个位、百位等）
//            if (digit % 2 != 1) return false;
//        }
//        else { // 偶数位（十位、千位等）
//            if (digit % 2 != 0) return false;
//        }
//    }
//    return true;
//}
//
//int main()
//{
//    stack<string> st;
//    string s;
//    while (cin >> s)
//    {
//        st.push(s);
//    }
//    while (st.empty())
//    {
//        cout << st.top() << " ";
//        st.pop();
//    }
//    return 0;
//}
//
//
//bool canFinish(int n, vector<vector<int>>& prerequisites)
//{
//    unordered_map<int, vector<int>> edges;//邻接表
//    vector<int> in(n);//入度
//    for (auto& e : prerequisites)
//    {
//        int a = e[0], b = e[1];//b->a的一边
//        edges[b].push_back(a);
//        in[a]++;
//    }
//    queue<int> q;
//    for (int i = 0; i < n; i++) if (in[i] == 0) q.push(i);
//    while (q.size())
//    {
//        int t = q.front();
//        q.pop();
//        for (int a : edges[t])
//        {
//            in[a]--;
//            if (in[a] == 0) q.push(a);
//        }
//    }
//    for (int i = 0; i < n; i++)
//        if (in[i]) return false;
//    return true;
//}
//int main()
//{
//    vector<vector<int>> prerequisites{ {1,0} ,{2,0},{3,0},{3,1},{3,2},{4,3} };
//    canFinish(5,prerequisites);
//    return 0;
//}

//int mySqrt(int x)
//{
//    if (x < 1) return 0;
//    int left = 1, right = x;
//    while (right > left)
//    {
//        long long mid = (right - left + 1) / 2 + left;
//        if (mid * mid <= x)left = mid;
//        else right = mid - 1;
//    }
//    return left;
//}
//
//int main()
//{
//    mySqrt(8);
//    return 0;
//}
int main()
{
    unorder_map<string, int> hash;
    string obj, s;
    cin >> obj;
    obj = tolower(obj);
    int count = 0, begin = 0;
    while (cin >> s)
    {
        count++;
        s = tolower(s);
        if (s == obj)
        {
            if (hash[s] == 0)begin = count;
            hash[s]++;
        }
    }
    if (hash[s] == 0) cout << -1;
    else cout << hash[obj] << begin;
    return 0;
}